{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.pipeline import FeatureUnion\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "import copy\n",
    "from sklearn.feature_extraction import FeatureHasher\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import preprocessing\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow import feature_column\n",
    "from tensorflow.keras import layers\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File System"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_DIR =  \"/Users/jackgraham/misc/handson-ml2/datasets/unsw/\"\n",
    "testing_fname = \"UNSW_NB15_testing-set.csv\"\n",
    "training_fname = \"UNSW_NB15_training-set.csv\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading and Feature Labeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = pd.read_csv(DATA_DIR + training_fname)\n",
    "df2 =  pd.read_csv(DATA_DIR  + testing_fname)\n",
    "df = df1.append(df2)\n",
    "\n",
    "\n",
    "label_feature = ['label']\n",
    "categorical_features = ['proto', 'service', 'state']\n",
    "drop_features = ['id', 'sttl', 'dttl', 'swin', 'dwin', 'trans_depth', 'response_body_len', 'ct_srv_src', 'ct_state_ttl', 'ct_dst_ltm', 'ct_src_dport_ltm', 'ct_dst_sport_ltm', 'ct_dst_src_ltm', 'is_ftp_login', 'ct_ftp_cmd', 'ct_flw_http_mthd', 'ct_src_ltm', 'ct_srv_dst', 'is_sm_ips_ports', 'attack_cat']\n",
    "numerical_features = list(set(df.columns) - set(label_feature) - set(categorical_features) - set(drop_features))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Observe the dataset\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x14de8dbd0>]],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.hist(column='rate',bins=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scaling\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.000074</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.000078</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.000014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.000014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.000033</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0\n",
       "0  0.000074\n",
       "1  0.000078\n",
       "2  0.000014\n",
       "3  0.000014\n",
       "4  0.000033"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float_array = df[['rate']].values.astype(float)\n",
    "min_max_scaler = preprocessing.MinMaxScaler()\n",
    "scaled_array = min_max_scaler.fit_transform(float_array)\n",
    "df_normalized = pd.DataFrame(scaled_array)\n",
    "df_normalized.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = preprocessing.MinMaxScaler()\n",
    "df[numerical_features] = scaler.fit_transform(df[numerical_features])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>dur</th>\n",
       "      <th>proto</th>\n",
       "      <th>service</th>\n",
       "      <th>state</th>\n",
       "      <th>spkts</th>\n",
       "      <th>dpkts</th>\n",
       "      <th>sbytes</th>\n",
       "      <th>dbytes</th>\n",
       "      <th>rate</th>\n",
       "      <th>...</th>\n",
       "      <th>ct_dst_sport_ltm</th>\n",
       "      <th>ct_dst_src_ltm</th>\n",
       "      <th>is_ftp_login</th>\n",
       "      <th>ct_ftp_cmd</th>\n",
       "      <th>ct_flw_http_mthd</th>\n",
       "      <th>ct_src_ltm</th>\n",
       "      <th>ct_srv_dst</th>\n",
       "      <th>is_sm_ips_ports</th>\n",
       "      <th>attack_cat</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.002025</td>\n",
       "      <td>tcp</td>\n",
       "      <td>-</td>\n",
       "      <td>FIN</td>\n",
       "      <td>0.000470</td>\n",
       "      <td>0.000363</td>\n",
       "      <td>0.000016</td>\n",
       "      <td>0.000012</td>\n",
       "      <td>0.000074</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>Normal</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>0.010832</td>\n",
       "      <td>tcp</td>\n",
       "      <td>-</td>\n",
       "      <td>FIN</td>\n",
       "      <td>0.001221</td>\n",
       "      <td>0.003449</td>\n",
       "      <td>0.000049</td>\n",
       "      <td>0.002866</td>\n",
       "      <td>0.000078</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>Normal</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>0.027052</td>\n",
       "      <td>tcp</td>\n",
       "      <td>-</td>\n",
       "      <td>FIN</td>\n",
       "      <td>0.000658</td>\n",
       "      <td>0.001452</td>\n",
       "      <td>0.000024</td>\n",
       "      <td>0.000900</td>\n",
       "      <td>0.000014</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>Normal</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>0.028027</td>\n",
       "      <td>tcp</td>\n",
       "      <td>ftp</td>\n",
       "      <td>FIN</td>\n",
       "      <td>0.001033</td>\n",
       "      <td>0.001089</td>\n",
       "      <td>0.000042</td>\n",
       "      <td>0.000053</td>\n",
       "      <td>0.000014</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>Normal</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>0.007491</td>\n",
       "      <td>tcp</td>\n",
       "      <td>-</td>\n",
       "      <td>FIN</td>\n",
       "      <td>0.000845</td>\n",
       "      <td>0.000545</td>\n",
       "      <td>0.000036</td>\n",
       "      <td>0.000018</td>\n",
       "      <td>0.000033</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>40</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>39</td>\n",
       "      <td>0</td>\n",
       "      <td>Normal</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 45 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   id       dur proto service state     spkts     dpkts    sbytes    dbytes  \\\n",
       "0   1  0.002025   tcp       -   FIN  0.000470  0.000363  0.000016  0.000012   \n",
       "1   2  0.010832   tcp       -   FIN  0.001221  0.003449  0.000049  0.002866   \n",
       "2   3  0.027052   tcp       -   FIN  0.000658  0.001452  0.000024  0.000900   \n",
       "3   4  0.028027   tcp     ftp   FIN  0.001033  0.001089  0.000042  0.000053   \n",
       "4   5  0.007491   tcp       -   FIN  0.000845  0.000545  0.000036  0.000018   \n",
       "\n",
       "       rate  ...  ct_dst_sport_ltm  ct_dst_src_ltm  is_ftp_login  ct_ftp_cmd  \\\n",
       "0  0.000074  ...                 1               1             0           0   \n",
       "1  0.000078  ...                 1               2             0           0   \n",
       "2  0.000014  ...                 1               3             0           0   \n",
       "3  0.000014  ...                 1               3             1           1   \n",
       "4  0.000033  ...                 1              40             0           0   \n",
       "\n",
       "   ct_flw_http_mthd  ct_src_ltm  ct_srv_dst  is_sm_ips_ports  attack_cat  \\\n",
       "0                 0           1           1                0      Normal   \n",
       "1                 0           1           6                0      Normal   \n",
       "2                 0           2           6                0      Normal   \n",
       "3                 0           2           1                0      Normal   \n",
       "4                 0           2          39                0      Normal   \n",
       "\n",
       "   label  \n",
       "0      0  \n",
       "1      0  \n",
       "2      0  \n",
       "3      0  \n",
       "4      0  \n",
       "\n",
       "[5 rows x 45 columns]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x14e14a490>]],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_normalized.hist(column=0,bins=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train, Validation, Test Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "164910 train examples\n",
      "41228 validation examples\n",
      "51535 test examples\n"
     ]
    }
   ],
   "source": [
    "train, test = train_test_split(df, test_size=0.2)\n",
    "train, val = train_test_split(train, test_size=0.2)\n",
    "print(len(train), 'train examples')\n",
    "print(len(val), 'validation examples')\n",
    "print(len(test), 'test examples')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A utility method to create a tf.data dataset from a Pandas Dataframe\n",
    "def df_to_dataset(dataframe, shuffle=True, batch_size=32):\n",
    "    dataframe = dataframe.copy()\n",
    "    labels = dataframe.pop('label')\n",
    "    dataframe = dataframe.drop(drop_features, axis=1)\n",
    "    ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels))\n",
    "    if shuffle:\n",
    "        ds = ds.shuffle(buffer_size=len(dataframe))\n",
    "    ds = ds.batch(batch_size)\n",
    "    return ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds = df_to_dataset(train)\n",
    "val_ds = df_to_dataset(val, shuffle=False)\n",
    "test_ds = df_to_dataset(test, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Every feature: ['dur', 'proto', 'service', 'state', 'spkts', 'dpkts', 'sbytes', 'dbytes', 'rate', 'sload', 'dload', 'sloss', 'dloss', 'sinpkt', 'dinpkt', 'sjit', 'djit', 'stcpb', 'dtcpb', 'tcprtt', 'synack', 'ackdat', 'smean', 'dmean']\n",
      "A batch of labels: tf.Tensor([0 1 0 0 1 0 0 1 1 1 0 1 1 1 0 0 1 1 1 1 1 1 1 1 0 1 0 1 1 0 1 0], shape=(32,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "for feature_batch, label_batch in train_ds.take(1):\n",
    "    print('Every feature:', list(feature_batch.keys()))\n",
    "    print('A batch of labels:', label_batch )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making Feature Columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# header is the name of the column\n",
    "# categories is all category names in that column\n",
    "# returns the one hot feature column\n",
    "def makeIndicatorFeatureColumn(header, categories):\n",
    "    r = feature_column.categorical_column_with_vocabulary_list(header, categories)\n",
    "    r_one_hot = feature_column.indicator_column(r)\n",
    "    return r_one_hot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# categorical columns\n",
    "one_hot_feature_columns = []\n",
    "for h in categorical_features:\n",
    "    fc = makeIndicatorFeatureColumn(h, df[h].unique())\n",
    "    one_hot_feature_columns.append(fc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_columns = one_hot_feature_columns\n",
    "\n",
    "# numeric columns\n",
    "for header in numerical_features:\n",
    "    feature_columns.append(feature_column.numeric_column(header))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have defined our feature columns, we will use a DenseFeatures layer to input them to our Keras model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_layer = tf.keras.layers.DenseFeatures(feature_columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Layer sequential is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
      "\n",
      "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
      "\n",
      "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
      "\n",
      "WARNING:tensorflow:From /Users/jackgraham/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/feature_column/feature_column_v2.py:4276: IndicatorColumn._variable_shape (from tensorflow.python.feature_column.feature_column_v2) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "The old _FeatureColumn APIs are being deprecated. Please use the new FeatureColumn APIs instead.\n",
      "WARNING:tensorflow:From /Users/jackgraham/anaconda3/envs/tf2/lib/python3.7/site-packages/tensorflow_core/python/feature_column/feature_column_v2.py:4331: VocabularyListCategoricalColumn._num_buckets (from tensorflow.python.feature_column.feature_column_v2) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "The old _FeatureColumn APIs are being deprecated. Please use the new FeatureColumn APIs instead.\n",
      "Epoch 1/5\n",
      "5154/5154 [==============================] - 53s 10ms/step - loss: 0.2341 - accuracy: 0.8622 - val_loss: 0.0000e+00 - val_accuracy: 0.0000e+00\n",
      "Epoch 2/5\n",
      "5154/5154 [==============================] - 43s 8ms/step - loss: 0.1899 - accuracy: 0.8892 - val_loss: 0.1847 - val_accuracy: 0.8857\n",
      "Epoch 3/5\n",
      "5154/5154 [==============================] - 43s 8ms/step - loss: 0.1794 - accuracy: 0.8952 - val_loss: 0.1761 - val_accuracy: 0.8969\n",
      "Epoch 4/5\n",
      "5154/5154 [==============================] - 43s 8ms/step - loss: 0.1714 - accuracy: 0.8987 - val_loss: 0.1706 - val_accuracy: 0.8967\n",
      "Epoch 5/5\n",
      "5154/5154 [==============================] - 43s 8ms/step - loss: 0.1676 - accuracy: 0.9001 - val_loss: 0.1665 - val_accuracy: 0.9049\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.Sequential([\n",
    "  feature_layer,\n",
    "  layers.Dense(128, activation='relu'),\n",
    "  layers.Dense(128, activation='relu'),\n",
    "  layers.Dense(1)\n",
    "])\n",
    "\n",
    "model.compile(optimizer='adam',\n",
    "              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "history = model.fit(train_ds,\n",
    "          validation_data=val_ds,\n",
    "          epochs=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1611/1611 [==============================] - 9s 6ms/step - loss: 0.1665 - accuracy: 0.9050\n",
      "Accuracy 0.9049772\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(test_ds)\n",
    "print(\"Accuracy\", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [0.2341393088366985,\n",
       "  0.1899405703129289,\n",
       "  0.17937619626236528,\n",
       "  0.17141801894911063,\n",
       "  0.16759876745562274],\n",
       " 'accuracy': [0.86222786, 0.8892184, 0.8952156, 0.8987144, 0.90006065],\n",
       " 'val_loss': [0.1988398337680189,\n",
       "  0.18469838385914197,\n",
       "  0.17608824689647498,\n",
       "  0.17064490802652912,\n",
       "  0.1665139734951665],\n",
       " 'val_accuracy': [0.8826283, 0.885733, 0.89689046, 0.89669645, 0.90491897]}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history.history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3dd3yV9fn/8deVkBAySEjYBGSIyB4iatWKW5ygrXVbOxy1FTus2orVan+1/Va7tLXa2mpttVZZbnDvKiNIGAoikBB2CCGBkHX9/rgPEOIBDpCTO+P9fDzy4Jxzj3Odm+R+n/v+3PfnY+6OiIhIfQlhFyAiIk2TAkJERKJSQIiISFQKCBERiUoBISIiUSkgREQkKgWECGBm/zCzu2Ocd7mZnRLvmkTCpoAQEZGoFBAiLYiZtQm7Bmk5FBDSbERO7dxkZh+bWbmZ/c3MupjZi2a2xcxeMbMOdeY/18wWmFmJmb1hZgPrTBtpZnMiy/0HSKn3XmebWV5k2ffMbFiMNZ5lZnPNrNTMCszsjnrTj4usryQy/euR19uZ2b1mtsLMNpvZO5HXxppZYZTtcErk8R1m9rSZPW5mpcDXzWyMmb0feY/VZna/mSXXWX6wmc00s2IzW2tmPzGzrma21cxy6sx3hJmtN7OkWD67tDwKCGluLgBOBQ4DzgFeBH4CdCT4fb4BwMwOA54AbgQ6AS8Az5pZcmRnORX4J5AN/DeyXiLLjgIeAa4BcoC/ANPNrG0M9ZUDVwBZwFnAdWY2PrLeXpF6/xipaQSQF1nuN8ARwJciNf0YqI1xm5wHPB15z38BNcD3I9vkGOBk4DuRGjKAV4CXgO7AocCr7r4GeAO4sM56LwOedPeqGOuQFkYBIc3NH919rbuvAt4G/ufuc919OzAFGBmZ72vA8+4+M7KD+w3QjmAHfDSQBPzO3avc/Wngozrv8W3gL+7+P3evcfdHge2R5fbK3d9w9/nuXuvuHxOE1AmRyZcCr7j7E5H33ejueWaWAHwDmOjuqyLv+V7kM8XifXefGnnPbe4+290/cPdqd19OEHA7ajgbWOPu97p7hbtvcff/RaY9ShAKmFkicDFBiEorpYCQ5mZtncfbojxPjzzuDqzYMcHda4ECoEdk2irfvafKFXUeHwL8MHKKpsTMSoCekeX2ysyOMrPXI6dmNgPXEnyTJ7KOz6Is1pHgFFe0abEoqFfDYWb2nJmtiZx2+n8x1AAwDRhkZn0JjtI2u/uHB1iTtAAKCGmpigh29ACYmRHsHFcBq4Eekdd26FXncQHwC3fPqvOT6u5PxPC+/wamAz3dPRN4ENjxPgVAvyjLbAAq9jCtHEit8zkSCU5P1VW/S+Y/A4uB/u7enuAU3L5qwN0rgKcIjnQuR0cPrZ4CQlqqp4CzzOzkSCPrDwlOE70HvA9UAzeYWRszOx8YU2fZh4FrI0cDZmZpkcbnjBjeNwModvcKMxsDXFJn2r+AU8zswsj75pjZiMjRzSPAfWbW3cwSzeyYSJvHp0BK5P2TgNuAfbWFZAClQJmZHQ5cV2fac0BXM7vRzNqaWYaZHVVn+mPA14Fzgcdj+LzSgikgpEVy908Izqf/keAb+jnAOe5e6e6VwPkEO8JNBO0Vk+ssO4ugHeL+yPSlkXlj8R3g52a2BbidIKh2rHclcCZBWBUTNFAPj0z+ETCfoC2kGPgVkODumyPr/CvB0U85sNtVTVH8iCCYthCE3X/q1LCF4PTROcAaYAlwYp3p7xI0js+JtF9IK2YaMEhE6jKz14B/u/tfw65FwqWAEJGdzOxIYCZBG8qWsOuRcOkUk4gAYGaPEtwjcaPCQUBHECIisgc6ghARkahaVMdeHTt29N69e4ddhohIszF79uwN7l7/3hqghQVE7969mTVrVthliIg0G2a2Yk/TdIpJRESiUkCIiEhUCggREYmqRbVBRFNVVUVhYSEVFRVhlxJXKSkp5ObmkpSksV1EpGG0+IAoLCwkIyOD3r17s3vnnS2Hu7Nx40YKCwvp06dP2OWISAvR4k8xVVRUkJOT02LDAcDMyMnJafFHSSLSuFp8QAAtOhx2aA2fUUQaV6sICBGRFskdPnsd3vldXFavgIizkpIS/vSnP+33cmeeeSYlJSVxqEhEmr0dwfDIGfDP8TDrb1C1rcHfRgERZ3sKiJqamr0u98ILL5CVlRWvskSkOaofDJsL4Kx74buzIKldg79di7+KKWy33HILn332GSNGjCApKYn09HS6detGXl4eCxcuZPz48RQUFFBRUcHEiRO5+uqrgV3dhpSVlTFu3DiOO+443nvvPXr06MG0adNo167hfxlEpIlyh2VvwBv3QMEH0L5HEAwjL4c2+xqB9sC1qoC489kFLCwqbdB1Durenp+dM3iP0++55x7y8/PJy8vjjTfe4KyzziI/P3/n5aiPPPII2dnZbNu2jSOPPJILLriAnJyc3daxZMkSnnjiCR5++GEuvPBCnnnmGS677LIG/Rwi0gSFFAw7tKqAaArGjBmz270Kf/jDH5gyZQoABQUFLFmy5AsB0adPH0aMGAHAEUccwfLlyxutXhEJQcjBsEOrCoi9fdNvLGlpaTsfv/HGG7zyyiu8//77pKamMnbs2Kj3MrRtu+sXIjExkW3bGr4xSkSagCYSDDu0qoAIQ0ZGBlu2RB+9cfPmzXTo0IHU1FQWL17MBx980MjViUiT4A6fvxkEw8r3IaM7nPkbGHVFKMGwgwIiznJycjj22GMZMmQI7dq1o0uXLjunnXHGGTz44IMMGzaMAQMGcPTRR4dYqYg0uiYaDDu0qDGpR48e7fUHDFq0aBEDBw4MqaLG1Zo+q0izFi0Yjv9BKMFgZrPdfXS0aTqCEBFpLE38iKE+BYSISLw1s2DYQQEhIhIvewqGkZdDUkrY1e2TAkJEpKG5w+dvRYLhvWYXDDsoIEREGkoLCYYdFBAiIgerhQXDDurNNc4OtLtvgN/97nds3bq1gSsSkQbjDsvehL+fCY+dC5s+D4Lhhrkw5tvNOhxAARF3CgiRFihaMIz7P7ghr0UEww46xRRndbv7PvXUU+ncuTNPPfUU27dvZ8KECdx5552Ul5dz4YUXUlhYSE1NDZMmTWLt2rUUFRVx4okn0rFjR15//fWwP4qIuMPyt4NTSSvehYxuQTCMuqLFhEJdrSsgXrwF1sxv2HV2HQrj7tnj5Lrdfc+YMYOnn36aDz/8EHfn3HPP5a233mL9+vV0796d559/Hgj6aMrMzOS+++7j9ddfp2PHjg1bs4jsn1YWDDu0roAI2YwZM5gxYwYjR44EoKysjCVLlnD88cfzox/9iJtvvpmzzz6b448/PuRKRQRotcGwQ1wDwszOAH4PJAJ/dfd76k3vADwC9AMqgG+4e34syx6QvXzTbwzuzq233so111zzhWmzZ8/mhRde4NZbb+W0007j9ttvD6FCEQFafTDsELdGajNLBB4AxgGDgIvNbFC92X4C5Ln7MOAKgkCIddlmoW5336effjqPPPIIZWVlAKxatYp169ZRVFREamoql112GT/60Y+YM2fOF5YVkUaw43LVf5wFj54Dxct2NT4fdXWTDAd3p6Jq72PcH6h4HkGMAZa6+zIAM3sSOA9YWGeeQcAvAdx9sZn1NrMuQN8Ylm0W6nb3PW7cOC655BKOOeYYANLT03n88cdZunQpN910EwkJCSQlJfHnP/8ZgKuvvppx48bRrVs3NVKLxNuO+xhWvAvpXWHcr2HUlY0eCu5OaUU1xeWVFJdvZ2NZJcXllWwsr4y8tuPxdorLgscdUpP54CcnN3gt8QyIHkBBneeFwFH15pkHnA+8Y2ZjgEOA3BiXBcDMrgauBujVq1eDFN7Q/v3vf+/2fOLEibs979evH6effvoXlvve977H9773vbjWJtLqfb7jVNI7cQmG2lqnZFvVPnf2O6Zt2lpJVU30YRjaJSWSnZZMTnoyHdPbcliXDHLSkunSPj4hFs+AsCiv1f/U9wC/N7M8YD4wF6iOcdngRfeHgIcgGA/igKsVkdblAIOhqqaWTXV28hvLKyku207x1iAEissrd+7sd+zwa/ewZ8pIaUNOWjLZacnkdkhleG4W2enJO1/LTksmJ60t2enJZKcm0y45MQ4bYs/iGRCFQM86z3OBorozuHspcBWAmRnweeQndV/LiogckHrBUHXaPaw/7CKKtyew8fMtFJdv2G0Hv9u3/bLtlFZUR12tGWS1S9q5U+/XKZ0j+0TZ2UeOADqkJpPcpmnfqxzPgPgI6G9mfYBVwEXAJXVnMLMsYKu7VwLfAt5y91Iz2+ey+8PdCfKn5WpJIwOKHCh3Z2tlTdRTN+mr3+folQ/Tb2sexQnZPJb0LR4tPYFN0xOB976wrjYJRoe0XTv4wd3bRx633fktv0NqsLPPjjxOTGhZ+5m4BYS7V5vZd4GXCS5VfcTdF5jZtZHpDwIDgcfMrIagAfqbe1v2QOpISUlh48aN5OTktNiQcHc2btxISkrTu8JC5GAcSIPt9ura3dZxdMJCbmzzDEcnLGI9HXgw9Wo+7HAO7TMymJDWducOPrtOGOSktaV9uzYtdp8RqxY/JnVVVRWFhYVUVFSEVFXjSElJITc3l6SkpLBLEdlvZdurmV+4mbyCEuYVlLB8Y/k+G2zTkhN3npvPjnyzr7uz71c+l8MW3U/Gmv9Rm94FO+772BFfh6R2jfvhmrhWPSZ1UlISffr0CbsMEYmorqnlk7VbmFewmbyCTcwr2Myn67aw47vqITmp9O+cwYieWbu+2adHAqDO+fyUpD002H7+Nrz5q+BGt/SucMavSDjiSgXDAWjxASEi4XF3VpVs23lkkFdQwvxVm6moCk4DdUhNYkTPLMYN7crwnlmMyM2iQ1rygb1ZlGBAwXBQFBAi0mA2b6vi48IS8laWMK8wCIQNZZUAJLdJYEj39lw8phcjemYxsmcHema3O/jz/MvfCa5KWv42pHdRMDQgBYSIHJDK6loWrS4NgmBlCXmFJSxbX75zer9OaZxwWGdG9MxkRM8ODOia0bCXdX4hGO4BtTE0KAWEiOyTu7Ni41byIqeJ8gpKWFhUSmVNcKqoY3pbRvTM4oJRuQzPzWJYz0zap8TpggkFQ6NRQIjIFxSXVzKvoIS5kbaDeYUllGytAoLuHobmZvL1Y3szomcWw3tm0T0zJf6XhCoYGp0CQqSVq6iqYUFR6W4NySuLg6FuEwwO65LBGYMjjcg9s+jfOZ02iY14B7CCITQKCJF427AE1i6AhESwxDr/JtR7vrfXE6LMt4/Xo3yjr611lm0oI6/OJaaLVpdSHeksqHtmCsN7ZnHpUb0Y3jOLoT0ySWsb0m5CwRA6BYRIvNRUwdv3wVu/htro/ffElSXglkgtCdSQQLUbVbVGBxI4gQSOJ4HENm1ok9GG5DZJJCcn0SaxDZQmwsJEWLwfQbW/4bXXUEyAT1/eFQyn/xJGX6VgCIECQiQe1i2GKdfA6jwY8hU49gbAwGugtjbyb029fw/u9cqqKtaWbGVNSTnrSreyfvNWtm6vJIFakqyWTmmJdE5PolNaGzqmtaF9cgLm0dZdG+W9Iq/XVEF1xQHWHGW9Xht9+6V1VjA0AQoIkYZUWwPvPwCv3Q1t0+Grj8Lg8Q3+NjW1zqdrtwRtBquCdoNP127Z2a10r+xUhh8atBmM6JnJ4O6Ze77zOEzu0YMjKQ0StXsKm/4HRBrKxs9g6neg4AM4/Gw4+7eQ3vmgV+vurN5csbMReW5BCfmrNrO1MhhmMis1ieG5WZw2uCsje2YxLDeTnPS2B/2+jcJs16klaXIUECIHq7YWZv0NZt4OCUkw4S8w7GtRG4ljUVpRtbPjuh0/67dsByA5MYFB3dtz4eiekaODLA7JSW31vY5KfCggRA5GSQFMux4+fxP6nQzn/hEye8S8eFVNLYtXbyGvTvcUn60v29lxXd9OaRx/aEdG9MpieG4WA7u1b/KDzEjLoYAQORDuMPdxeOnW4Bz62b8LLsHcyzd5d6egeBtzI5eX5hVsYkFR6c7xCzqmJzOiZxbnDe/OiF5ZDOuRRWaqum+X8CggRPbXljUw/QZY8jIcciyc9wBkR+9Sfm1pBdPzinjvsw3MK9xMcXnQcV1KUgJDe2RyxTGH7LwBrUdWA3RcJ9KAFBAisXKH/Gfg+R8Gl3qe/ks46trgGv46tlZW8/KCNUyes4p3l26g1qF/53ROGdiZET07MLxnJgO6ZDTu3cgiB0ABIRKL8o3w/A9g4VToMRomPAgd+++cXFPrvP/ZRibPLeSl/DVsrawht0M7vnvioYwf2YO+ndJDLF7kwCggRPZl8fPw7ETYVgIn3w5fmrjzGv1P1mxh8txCps0tYk1pBRkpbThvRHcmjMxl9CEdSGhhg9hL66KAENmTbSXw0i0w7wnoOhQunwpdh7BuSwXT81YyZe4qFhSV0ibBGDugE5POHsTJAzs3zRvSRA6AAkIkmqWvwrTvQtla+PKPqfjSD5jxySYmv/ghby/ZQE2tMyw3kzvOGcQ5w7s3nxvTRPaDAkKkru1lMHMSzHoE7ziA+cc9wD9X5vDiL9+ibHs13TNTuPaEvkwYmcuhndWuIC2bAkJkh+XvwtTr8JKVfNTtUm4uPpfPp2wjve0axg3pyvmjcjmqT7baFaTVUECIVG1j20s/I2X2Q6xJ6ML3tk9i7oqBHN8/m++fmcupA7vQLlntCtL6KCCk1aqoqmHWu6/Q790f0q2qgMeqT2Vap6sZd+Kh/GlEdzpnpIRdokioFBDSqrg7Hy3fxPTZn9Mr/36+6VPYYNk8cfjvOWrsBVzRNSPsEkWaDAWEtAqfbyhnypxCpuStIn3TYn6b/GcOt5Ws7fcVOn7lXi5OzQq7RJEmRwEhLdam8kqem7+ayXMKmbuyhCSr4f91fpULUh7HUrPh3CfpMmBc2GWKNFkKCGlRtlfX8Pri9UyeU8jrn6yjqsY5vGsGv/pyMhNW3E3y2jwYfD6cdS+kZoddrkiTpoCQZs/dmbOyhClzC3l23mo2b6uiU0ZbrjymN+eP6Maglf+CV38OyanwlUdgyAVhlyzSLCggpNlauXErU+auYsrcQpZv3EpKUgKnD+7KhJE9OO7QjrTZvBymXgIr34PDxsE5v4eMLmGXLdJsKCCkWdm8rYrnP17NlLmFfLR8E2ZwTN8crj/xUMYN7UZ62zZBt9yzHoEZk4Kxjsf/GYZffMBDgIq0VgoIafKqamp585P1TJ5byCuL1lFZXcuhndP58RkDGD+iB92z2u2aeXNh0IfSsteh74lw3v2QmRte8SLNmAJCmiR35+PCzUyZu4rp84ooLq8kJy2ZS4/qxfkjcxnSo/3uo6+5B72uvngz1NbAWffB6G/oqEHkICggpEkp3LSVaXlFPDOnkGXry0luk8Cpg7pwwageHN+/E0nRRmHbshaeuxE+eQF6fQnGPwDZfRu/eJEWRgEhodtSUcWL89cweW4hHywrBmBMn2yu+XJfxg3tRvuUpD0vvGAKPPcDqCyH034BR18XtDuIyEFTQEgoqmtqeXvJBibPXcWMBWvYXl1L345p/PDUwxg/sgc9s1P3voKtxcHY0AsmQ/dRwRCgnQY0TvEirURcA8LMzgB+DyQCf3X3e+pNzwQeB3pFavmNu/89Mm0i8G3AgIfd/XfxrFXiz91ZUFTK5DlBu8KGsu1kpSbxtSN7MmFkD0b0zNq9XWFPPnkxGAJ0azGcdBsc+/2dQ4CKSMOJ21+VmSUCDwCnAoXAR2Y23d0X1pntemChu59jZp2AT8zsX8BhBOEwBqgEXjKz5919SbzqlfhZvXkbU+cWMWVuIZ+uLSM5MYGTB3ZmwsgejB3QmeQ2UdoVoqnYDC/9BPIehy5D4NKnoduw+BYv0orF82vXGGCpuy8DMLMngfOAugHhQIYFXxvTgWKgGhgIfODuWyPLvglMAH4dx3qlAZVvr+al/KBd4b3PNuIORxzSgV9MGMLZQ7uTmbqXdoVoPns9uHx1SxEc/0M44WZoo2E+ReIpngHRAyio87wQOKrePPcD04EiIAP4mrvXmlk+8AszywG2AWcCs6K9iZldDVwN0KtXrwb9ALJ/amqdd5duYMrcVbyUv4ZtVTX0yk5l4sn9mTCyB4fkpO3/SivLYebt8NFfIac/fHMm5I5u+OJF5AviGRDRTiZ7veenA3nASUA/YKaZve3ui8zsV8BMoAyYR3Bk8cUVuj8EPAQwevTo+uuXRrBodSlT5q5iWt4q1pZup31KGyaM6sEFo3owqleH2NoVolnxPky9DjYth6Ovh5MnQVK7fS4mIg0jngFRCPSs8zyX4EihrquAe9zdgaVm9jlwOPChu/8N+BuAmf2/yPqkiVhXWsG0vCImz13FotWlJCUaYwd05vyRPThpYGfatjmIS02rKuD1u+G9+yGrF3z9Oeh9XMMVLyIxiWdAfAT0N7M+wCrgIuCSevOsBE4G3jazLsAAYEebRWd3X2dmvYDzgWPiWKvEyN25dfJ8nppVQK3DiJ5Z/Py8wZw9rDvZackH/warZsOU62DDJ3DEVXDaXdBWo7yJhCFuAeHu1Wb2XeBlgstcH3H3BWZ2bWT6g8BdwD/MbD7BKamb3X1DZBXPRNogqoDr3X1TvGqV2D338Wqe/KiAi8f04lvH96Ffp/SGWXF1Jbz1f/D2vZDeBS57Bg49pWHWLSIHxIKzOy3D6NGjfdasqG3Z0gC2VFRx8r1v0rl9W6ZdfxyJCQ3Uz9HaBTDlGlgzP+h19Yx7oJ2GABVpDGY2292jXvmhu4skZr97ZQnry7bz0BWjGyYcaqrhvd/D678MAuGif8PhZx38ekWkQSggJCYLi0r5x3vLuWRML0b0bIBv9xuWwJRrYdUsGHQenPVbSMs5+PWKSINRQMg+1dY6k6blk9kuiZtOP8j+jmpr4cO/wCt3QJsUuOBvwRCg6pZbpMlRQMg+PT27kNkrNvF/XxlGVupBXKm0aTlMvR5WvAP9T4dz/wAZXRusThFpWDEFhJk9AzwCvOjutfEtSZqSTeWV/PLFRRzZuwMXjDrAkdncYfY/YMZtgMF5D8CIS3XUINLExdhLGn8muIdhiZndY2aHx7EmaUJ+/fJiSiuquWv8EBIOpGG6tAgevyAY0KfHKPjOezDyMoWDSDMQ0xGEu78CvBLpnvtigi4xCoCHgcfdvSqONUpI5qzcxJMfFfCt4/pweNf2+7ewO3z8FLx4E9RUwZm/gdHfhIRYv5OISNhiboOI3LR2GXA5MBf4F3AccCUwNh7FSXiqa2qZNDWfLhkpTDzlsP1buGx9cMSw+DnoeRSM/zPk9ItPoSISN7G2QUwm6CPpn8A57r46Muk/ZqY701qgxz9YwYKiUv506SjS2+7HtQwLp8Fz34ftW+DUu+CY6zUEqEgzFetf/v3u/lq0CXu6A0+ar3WlFdw741OO79+RcUNivMpoazG8+GOY/1/oNiIYArTzwPgWKiJxFesJ4YFmtvPuKDPrYGbfiVNNErJfvLCI7dW1/Py8IbF11f3pDPjTMbBgCpz4U/jWKwoHkRYg1oD4truX7HgS6Tjv2/EpScL03tINTMsr4tqx/ejTcR8D/FSUBqO8/furkJoN334NTvgxJO7naHEi0iTFeoopwcwsMm7DjvGmG6BvZ2lKKqtrmTQtn17ZqXxn7D4alZe9CdOuh9JVcNz3YeytGgJUpIWJNSBeBp4yswcJRoW7FngpblVJKP76zjI+W1/O3686kpSkeg3LFaWwNj/ocXXlB7BgMuQcCt+YAT2PDKdgEYmrWAPiZuAa4DqCcRtmAH+NV1HS+Ao3beUPry7hjEFdOLFbDXz6Mqz5GFZ/HITCps93zZyaEwwBetJtkJwaXtEiElcaD6I1q62BjUthzXxeemUGGSWLODp1FYnbNu6ap0Mf6DYMug6FrsOCn4yuuhNapIU46PEgzKw/8EtgEJCy43V379sgFUr8VW6FdQuDo4I184Mjg7ULoHobACd5Ipsz+pPYf1wkCIZClyGQsp93UItIixHrKaa/Az8DfgucCFxFcKpJmqLyDbsHwZr5sHEJ7OhnsW1mcFQw+ioqOw7m2zMrWZfci2kTT4I26gpDRAKxBkQ7d381ciXTCuAOM3ubIDQkLO5B28Ca+buHwZaiXfO0zw3CYPD4XaeJsnrtPEX0h5c/4c3NS3ny6pEkKxxEpI5YA6LCzBIIenP9LrAK6By/suQLqith/aLdw2BtPmwvDaZbInQaAH2Or9NeMDS4P2EPPltfxl/e+ozzR/bg6L4azU1EdhdrQNwIpAI3AHcRnGa6Ml5FtXoVm794VLB+MdRGOs1NSoOuQ2DYhbvCoPNASGoX81u4Oz+btoCUpERuPVN3PYvIF+0zICI3xV3o7jcBZQTtD9IQ3IMbzXaGwbzg35IVu+ZJ6xycIup/yq6riLL7HHQHeM99vJp3lm7grvMG0ylDN7iJyBftMyDcvcbMjqh7J7UcgJrqoKF4zfzd7y/YVhyZwYIusXuMgiOuhK7Dg6ODjC4NXsqWiiruem4hQ3tkcslRhzT4+kWkZYj1FNNcYJqZ/Rco3/Giu0+OS1XNXWV5cAlp3SBYtxCqK4LpiW2hyyAYePauo4Iug6BtRqOU99uZS1hftp2HrxhN4oGMEicirUKsAZENbAROqvOaAwqIsnVRLildSrB5gJSs4BTRkd/a1XDcsX9oHdotKNrMP977nEvG9GJ4z6x9LyAirVasQ46q3aG2NnJJaZ2jgjXzoWzNrnmyegUhMPSrkcbjoZCZ22TuOq6tdSZNzadDajI/Pl3DiovI3sV6J/Xf2fmVeBd3/0aDV9QUVG+P3HVc56hgbT5UlgXTE9pAp8Oh34m7jgq6DoF2HcKtex/+O7uAOStL+M1Xh5OZqi65RWTvYj3F9FydxynABKBoD/M2L7U1sOLd3cNgwydQWx1MT84Idv4jLt11VNB5YLPr2npTeSX3vLiYMb2zuWBUj7DLEZFmINZTTM/UfW5mTwCvxKWiMPz7a1C1FTK6BQEwYNyuMOjQBxKa/x3Gv355MaUV1dw1PsZR4kSk1duP0eh30x/o1ZCFhCYhEa6YDh16Q2qz+dMAABIxSURBVHqnsKuJizkrN/HEhwVc/eW+DOjaOFdKiUjzF2sbxBZ2b4NYQzBGRMvQgge8qa6p5bYp+XRtn8LEk/uHXY6INCOxnmLS185m6p8frGDh6lL+dOko0toe6AGjiLRGMZ1cN7MJZpZZ53mWmY2PX1nSENaVVnDvjE/58mGdGDeka9jliEgzE2vr68/cffOOJ+5egrr6bvLufn4RlTW1/PzcwWqYFpH9FmtARJtP5yuasHeXbmD6vCKuO6EfvTumhV2OiDRDsQbELDO7z8z6mVlfM/stMDuehcmBq6yuZdK0fA7JSeW6sf3CLkdEmqlYA+J7QCXwH+ApYBtwfbyKkoPz8NvLWLa+nDvOHUxK0sF1Cy4irVdMAeHu5e5+i7uPjvz8xN3L97WcmZ1hZp+Y2VIzuyXK9Ewze9bM5pnZAjO7qs6070deyzezJ8wsZf8+WutUULyVP762hHFDunLiAA36JyIHLtarmGaaWVad5x3M7OV9LJMIPACMAwYBF5vZoHqzXQ8sdPfhwFjgXjNLNrMeBKPXjXb3IUAicFGMn6lVu/PZhSSYMens+ptaRGT/xHqKqWPkyiUA3H0T+x6Tegyw1N2XuXsl8CRwXr15HMiw4BKbdKAYiHSCRBugnZm1IRjutGX0/RRHMxeu5ZVFa5l4cn+6Z8U+/KiISDSxBkStme3sWsPMehOld9d6egAFdZ4XRl6r635gIMHOfz4w0d1r3X0V8BtgJbAa2OzuM2KstVXaVlnDHdMX0L9zOt84rk/Y5YhICxBrQPwUeMfM/mlm/wTeBG7dxzLRLryvHyqnA3lAd2AEcL+ZtTezDgRHG30i09LM7LKob2J2tZnNMrNZ69evj/HjtDz3v76EVSXbuHv8EJISm3/ngiISvlgbqV8CRgOfEFzJ9EOCK5n2phDoWed5Ll88TXQVMNkDS4HPgcOBU4DP3X29u1cRjFz3pT3U9tCOxvNOnVpmZ3v78tn6Mh56axnnj+rBUX1zwi5HRFqIWDvr+xYwkWAnnwccDbzP7kOQ1vcR0N/M+gCrCBqZL6k3z0rgZOBtM+sCDACWERx9HG1mqQRBdDIwK8bP1Kq4O7dPy6ddUiK3jhsYdjki0oLEei5iInAksMLdTwRGAns9n+Pu1cB3gZeBRcBT7r7AzK41s2sjs90FfMnM5gOvAje7+wZ3/x/wNDCHoG0iAXho/z5a6/Dsx6t5d+lGbjrjcDplNK9BjESkaYu1u4wKd68wM8ysrbsvNrMB+1rI3V8AXqj32oN1HhcBp+1h2Z+h/p72qrSiirueW8iw3EwuGdMyhucQkaYj1oAojNwHMRWYaWab0GWnofvtzE/ZULadv105msQEdcYnIg0r1vEgJkQe3mFmrwOZwEtxq0r2aUHRZh59bzmXHtWLYblZ+15ARGQ/7XePrO7+ZjwKkdjV1jq3Tc2nQ2oyN512eNjliEgLpQvmm6GnZhUwd2UJPzlzIJmpSWGXIyItlAKimSkur+SelxYzpnc254+qf2O6iEjDUUA0M79+aTFlFdXcNX6IRokTkbhSQDQjs1ds4smPCvjmcX0Y0DUj7HJEpIVTQDQT1TW13DY1n26ZKdxwcv+wyxGRVkAB0Uw89v4KFq0u5fazB5HWVsOBi0j8KSCagbWlFdw381NOOKwTZwzpGnY5ItJKKCCagbufX0RlTS13njtYDdMi0mgUEE3cu0s38Oy8Ir4zth+9O6aFXY6ItCIKiCZse3UNk6blc0hOKtee0C/sckSklVFrZxP217c/Z9n6cv5x1ZGkJCWGXY6ItDI6gmiiCoq38odXl3Dm0K6MHdA57HJEpBVSQDRRdz67gMQEY9LZg8IuRURaKQVEEzRz4VpeWbSOG0/pT7fMdmGXIyKtlAKiidlWWcMd0xdwWJd0rjq2T9jliEgrpkbqJub+15ewqmQbT11zDEmJym8RCY/2QE3I0nVlPPTWMi4YlcuYPtlhlyMirZwCoolwd26flk+7pERuPVOjxIlI+BQQTcT0eUW899lGfnzG4XRMbxt2OSIiCoimoLSiirufX8Sw3EwuHtMr7HJERAA1UjcJ9834lA1l2/nblaNJTFBnfCLSNOgIImT5qzbz2PvLueyoQxiWmxV2OSIiOykgQlRb60yalk92WjI/Om1A2OWIiOxGARGip2YVMHdlCT85cyCZqUlhlyMishsFREiKyyu556XFjOmTzYSRPcIuR0TkCxQQIfnVi4spq6jm7vFDNEqciDRJCogQzF5RzH9mFfDN4/twWJeMsMsREYlKAdHIqmtq+emUfLplpnDDSf3DLkdEZI8UEI3s0fdXsHjNFn52ziDS2uo2FBFpuhQQjWhtaQW/nfkpYwd04vTBXcMuR0RkrxQQjeju5xdRWVPLnecOVsO0iDR5CohG8s6SDTw7r4jrxx7KITlpYZcjIrJPCohGsL26htun5dM7J5VrTugbdjkiIjFRK2kjePitZSzbUM5j3xhDSlJi2OWIiMRERxBxVlC8lT++tpQzh3bly4d1CrscEZGYxTUgzOwMM/vEzJaa2S1Rpmea2bNmNs/MFpjZVZHXB5hZXp2fUjO7MZ61xoO787PpC0hMMCadPSjsckRE9kvcTjGZWSLwAHAqUAh8ZGbT3X1hndmuBxa6+zlm1gn4xMz+5e6fACPqrGcVMCVetcbLzIVreW3xOn565kC6ZbYLuxwRkf0SzyOIMcBSd1/m7pXAk8B59eZxIMOCaz7TgWKgut48JwOfufuKONba4LZWVnPnswsZ0CWDrx/bO+xyRET2WzwDogdQUOd5YeS1uu4HBgJFwHxgorvX1pvnIuCJPb2JmV1tZrPMbNb69esPvuoGcv9rS1lVso27JwwhKVFNPSLS/MRzzxXtTjCv9/x0IA/oTnBK6X4za79zBWbJwLnAf/f0Ju7+kLuPdvfRnTo1jUbgpeu28PDby/jKEbkc2Ts77HJERA5IPAOiEOhZ53kuwZFCXVcBkz2wFPgcOLzO9HHAHHdfG8c6G5S7M2nqAlKT23DruMP3vYCISBMVz4D4COhvZn0iRwIXAdPrzbOSoI0BM+sCDACW1Zl+MXs5vdQUTZ9XxPvLNnLT6QPISW8bdjkiIgcsblcxuXu1mX0XeBlIBB5x9wVmdm1k+oPAXcA/zGw+wSmpm919A4CZpRJcAXVNvGpsaKUVVdz13CKG52Zy8ZheYZcjInJQ4nontbu/ALxQ77UH6zwuAk7bw7JbgZx41tfQ7pvxKRvLt/P3rx9JYoI64xOR5k2X1zSQ/FWbeez95Vx+9CEMzc0MuxwRkYOmgGgAtbXObVPzyU5L5oenDQi7HBGRBqGAaAD/mVVAXkEJPz1rIJntksIuR0SkQSggDtLGsu3c8+JijuqTzfgR9e8DFBFpvhQQB+lXLy2mfHs1d48folHiRKRFUUAchFnLi3lqViHfPL4P/btkhF2OiEiDUkAcoOqaWm6bmk/3zBRuOKl/2OWIiDQ4BcQBevT9FSxes4XbzxlMWlsNzCciLY8C4gCs2VzBfTM+4cQBnTh9cJewyxERiQsFxAG4+/mFVNc6d56rhmkRabkUEPvp7SXree7j1Vx/4qH0ykkNuxwRkbhRQOyH7dU13D5tAX06pnH1l/uGXY6ISFypdXU/PPTmMj7fUM5j3xhDSlJi2OWIiMSVjiBitHLjVu5/fSlnDe3Glw9rGiPXiYjEkwIiBu7OHc8uoE2CMensQWGXIyLSKBQQMZi5cC2vLV7H9089jK6ZKWGXIyLSKBQQ+7C1spo7n13I4V0zuPJLvcMuR0Sk0aiReh/++NpSVpVs47/XHkNSovJURFoP7fH2YsnaLTz81jK+ekQuR/bODrscEZFGpYDYA3dn0rR80tq24ZZxh4ddjohIo1NA7MG0vCI+WFbMj88YQE5627DLERFpdAqIKDZvq+Lu5xcxvGcWFx3ZK+xyRERCoUbqKH4781OKy7fz968fSWKCOuMTkdZJRxD15K/azGPvL+fyow9haG5m2OWIiIRGAVFHba3z06n5ZKe15QenDQi7HBGRUCkg6njyowLmFZRw21kDyWyXFHY5IiKhUkBEbCzbzq9eWszRfbM5b0T3sMsREQmdAiLinhcXU769mrvO0yhxIiKggABg1vJi/ju7kG8d35f+XTLCLkdEpElo9QFRXVPLbVPz6Z6Zwg0nHxp2OSIiTUarvw+iorqWoT0yOWVQF1KTW/3mEBHZqdXvEdPbtuH/vjo87DJERJqcVn+KSUREolNAiIhIVAoIERGJSgEhIiJRKSBERCQqBYSIiESlgBARkagUECIiEpW5e9g1NBgzWw+sOMDFOwIbGrCchqK69o/q2j+qa/+0xLoOcfdO0Sa0qIA4GGY2y91Hh11Hfapr/6iu/aO69k9rq0unmEREJCoFhIiIRKWA2OWhsAvYA9W1f1TX/lFd+6dV1aU2CBERiUpHECIiEpUCQkREompVAWFmZ5jZJ2a21MxuiTLdzOwPkekfm9moJlLXWDPbbGZ5kZ/bG6muR8xsnZnl72F6WNtrX3WFtb16mtnrZrbIzBaY2cQo8zT6NouxrkbfZmaWYmYfmtm8SF13RpknjO0VS12h/I5F3jvRzOaa2XNRpjXs9nL3VvEDJAKfAX2BZGAeMKjePGcCLwIGHA38r4nUNRZ4LoRt9mVgFJC/h+mNvr1irCus7dUNGBV5nAF82kR+x2Kpq9G3WWQbpEceJwH/A45uAtsrlrpC+R2LvPcPgH9He/+G3l6t6QhiDLDU3Ze5eyXwJHBevXnOAx7zwAdAlpl1awJ1hcLd3wKK9zJLGNsrlrpC4e6r3X1O5PEWYBHQo95sjb7NYqyr0UW2QVnkaVLkp/5VM2Fsr1jqCoWZ5QJnAX/dwywNur1aU0D0AArqPC/ki38kscwTRl0Ax0QOeV80s8FxrilWYWyvWIW6vcysNzCS4NtnXaFus73UBSFss8jpkjxgHTDT3ZvE9oqhLgjnd+x3wI+B2j1Mb9Dt1ZoCwqK8Vv9bQSzzNLRY3nMOQX8pw4E/AlPjXFOswthesQh1e5lZOvAMcKO7l9afHGWRRtlm+6grlG3m7jXuPgLIBcaY2ZB6s4SyvWKoq9G3l5mdDaxz99l7my3Kawe8vVpTQBQCPes8zwWKDmCeRq/L3Ut3HPK6+wtAkpl1jHNdsQhje+1TmNvLzJIIdsL/cvfJUWYJZZvtq66wf8fcvQR4Azij3qRQf8f2VFdI2+tY4FwzW05wKvokM3u83jwNur1aU0B8BPQ3sz5mlgxcBEyvN8904IrIlQBHA5vdfXXYdZlZVzOzyOMxBP9vG+NcVyzC2F77FNb2irzn34BF7n7fHmZr9G0WS11hbDMz62RmWZHH7YBTgMX1Zgtje+2zrjC2l7vf6u657t6bYD/xmrtfVm+2Bt1ebQ683ObF3avN7LvAywRXDj3i7gvM7NrI9AeBFwiuAlgKbAWuaiJ1fQW4zsyqgW3ARR65ZCGezOwJgqs1OppZIfAzgga70LZXjHWFsr0IvuFdDsyPnL8G+AnQq05tYWyzWOoKY5t1Ax41s0SCHexT7v5c2H+TMdYV1u/YF8Rze6mrDRERiao1nWISEZH9oIAQEZGoFBAiIhKVAkJERKJSQIiISFQKCJEmwILeQb/QO6dImBQQIiISlQJCZD+Y2WUWjBWQZ2Z/iXTqVmZm95rZHDN71cw6ReYdYWYfWNAv/xQz6xB5/VAzeyXS0dscM+sXWX26mT1tZovN7F877tQVCYsCQiRGZjYQ+BpwbKQjtxrgUiANmOPuo4A3Ce7sBngMuNndhwHz67z+L+CBSEdvXwJ2dIUwErgRGEQwPsixcf9QInvRarraEGkAJwNHAB9Fvty3I+gOuhb4T2Sex4HJZpYJZLn7m5HXHwX+a2YZQA93nwLg7hUAkfV96O6Fked5QG/gnfh/LJHoFBAisTPgUXe/dbcXzSbVm29v/dfs7bTR9jqPa9Dfp4RMp5hEYvcq8BUz6wxgZtlmdgjB39FXIvNcArzj7puBTWZ2fOT1y4E3I+MwFJrZ+Mg62ppZaqN+CpEY6RuKSIzcfaGZ3QbMMLMEoAq4HigHBpvZbGAzQTsFwJXAg5EAWMaunjUvB/5iZj+PrOOrjfgxRGKm3lxFDpKZlbl7eth1iDQ0nWISEZGodAQhIiJR6QhCRESiUkCIiEhUCggREYlKASEiIlEpIEREJKr/D4aZ1aj0lfV5AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# list all data in history\n",
    "print(history.history.keys())\n",
    "# summarize history for accuracy\n",
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()\n",
    "# summarize history for loss\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
